package com.huaxiafinance.management.util;


import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.Schema;
import com.dyuproject.protostuff.runtime.RuntimeSchema;
import org.apache.log4j.Logger;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.List;


/**
 * <pre>
 * 序列号工具
 * </pre>
 *
 * @author F.Fang
 */
public class ProtoStuffSerializerUtil
{
    private static final Logger logger = Logger.getLogger(ProtoStuffSerializerUtil.class);

    public static <T> byte[] serialize(T obj)
    {
        if (obj == null)
        {
            throw new RuntimeException("序列化对象(null)!");
        }
        @SuppressWarnings("unchecked")
        Schema<T> schema = (Schema<T>)RuntimeSchema.getSchema(obj.getClass());
        LinkedBuffer buffer = LinkedBuffer.allocate(1024 * 1024);
        byte[] protostuff = null;
        try
        {
            protostuff = ProtostuffIOUtil.toByteArray(obj, schema, buffer);
        }
        catch (Exception e)
        {
            throw new RuntimeException("序列化(" + obj.getClass() + ")对象(" + obj + ")发生异常!", e);
        }
        finally
        {
            buffer.clear();
        }
        return protostuff;
    }

    public static <T> T deserialize(byte[] paramArrayOfByte, Class<T> targetClass)
    {
        if (paramArrayOfByte == null || paramArrayOfByte.length == 0)
        {
            throw new RuntimeException("反序列化对象发生异常,byte序列为空!");
        }
        T instance = null;
        try
        {
            instance = targetClass.newInstance();
        }
        catch (InstantiationException | IllegalAccessException e)
        {
            throw new RuntimeException("反序列化过程中依据类型创建对象失败!", e);
        }
        Schema<T> schema = RuntimeSchema.getSchema(targetClass);
        ProtostuffIOUtil.mergeFrom(paramArrayOfByte, instance, schema);
        return instance;
    }

    public static <T> byte[] serializeList(List<T> objList)
    {
        if (objList == null || objList.isEmpty())
        {
            throw new RuntimeException("序列化对象列表(" + objList + ")参数异常!");
        }
        @SuppressWarnings("unchecked")
        Schema<T> schema = (Schema<T>)RuntimeSchema.getSchema(objList.get(0).getClass());
        LinkedBuffer buffer = LinkedBuffer.allocate(1024 * 1024);
        byte[] protostuff = null;
        ByteArrayOutputStream bos = null;
        try
        {
            bos = new ByteArrayOutputStream();
            ProtostuffIOUtil.writeListTo(bos, objList, schema, buffer);
            protostuff = bos.toByteArray();
        }
        catch (Exception e)
        {
            throw new RuntimeException("序列化对象列表(" + objList + ")发生异常!", e);
        }
        finally
        {
            buffer.clear();
            try
            {
                if (bos != null)
                {
                    bos.close();
                }
            }
            catch (IOException e)
            {
                logger.error("错误++++++" + e);
            }
        }

        return protostuff;
    }

    public static <T> List<T> deserializeList(byte[] paramArrayOfByte, Class<T> targetClass)
    {
        if (paramArrayOfByte == null || paramArrayOfByte.length == 0)
        {
            throw new RuntimeException("反序列化对象发生异常,byte序列为空!");
        }

        Schema<T> schema = RuntimeSchema.getSchema(targetClass);
        List<T> result = null;
        try
        {
            result = ProtostuffIOUtil.parseListFrom(new ByteArrayInputStream(paramArrayOfByte),
                schema);
        }
        catch (IOException e)
        {
            throw new RuntimeException("反序列化对象列表发生异常!", e);
        }
        return result;
    }
}
